home *** CD-ROM | disk | FTP | other *** search
/ Erotic Games: Memory / Erotic Games: Memory.iso / mac / air_installers / AdobeAIR.exe / setup.swf / scripts / mx / collections / ListCollectionView.as < prev    next >
Text File  |  2009-02-12  |  42KB  |  1,474 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.Proxy;
  6.    import flash.utils.flash_proxy;
  7.    import flash.utils.getQualifiedClassName;
  8.    import mx.collections.errors.CollectionViewError;
  9.    import mx.collections.errors.ItemPendingError;
  10.    import mx.core.IMXMLObject;
  11.    import mx.core.mx_internal;
  12.    import mx.events.CollectionEvent;
  13.    import mx.events.CollectionEventKind;
  14.    import mx.events.PropertyChangeEvent;
  15.    import mx.resources.IResourceManager;
  16.    import mx.resources.ResourceManager;
  17.    import mx.utils.ObjectUtil;
  18.    
  19.    use namespace mx_internal;
  20.    
  21.    public class ListCollectionView extends Proxy implements ICollectionView, IList, IMXMLObject
  22.    {
  23.       
  24.       mx_internal static const VERSION:String = "3.0.0.0";
  25.        
  26.       
  27.       private var autoUpdateCounter:int;
  28.       
  29.       private var _list:IList;
  30.       
  31.       private var _filterFunction:Function;
  32.       
  33.       protected var localIndex:Array;
  34.       
  35.       mx_internal var dispatchResetEvent:Boolean = true;
  36.       
  37.       private var pendingUpdates:Array;
  38.       
  39.       private var resourceManager:IResourceManager;
  40.       
  41.       private var eventDispatcher:EventDispatcher;
  42.       
  43.       private var revision:int;
  44.       
  45.       private var _sort:Sort;
  46.       
  47.       public function ListCollectionView(param1:IList = null)
  48.       {
  49.          resourceManager = ResourceManager.getInstance();
  50.          super();
  51.          eventDispatcher = new EventDispatcher(this);
  52.          this.list = param1;
  53.       }
  54.       
  55.       private function handlePendingUpdates() : void
  56.       {
  57.          var _loc1_:Array = null;
  58.          var _loc2_:CollectionEvent = null;
  59.          var _loc3_:int = 0;
  60.          var _loc4_:CollectionEvent = null;
  61.          var _loc5_:int = 0;
  62.          if(pendingUpdates)
  63.          {
  64.             _loc1_ = pendingUpdates;
  65.             pendingUpdates = null;
  66.             _loc3_ = 0;
  67.             while(_loc3_ < _loc1_.length)
  68.             {
  69.                if((_loc4_ = _loc1_[_loc3_]).kind == CollectionEventKind.UPDATE)
  70.                {
  71.                   if(!_loc2_)
  72.                   {
  73.                      _loc2_ = _loc4_;
  74.                   }
  75.                   else
  76.                   {
  77.                      _loc5_ = 0;
  78.                      while(_loc5_ < _loc4_.items.length)
  79.                      {
  80.                         _loc2_.items.push(_loc4_.items[_loc5_]);
  81.                         _loc5_++;
  82.                      }
  83.                   }
  84.                }
  85.                else
  86.                {
  87.                   listChangeHandler(_loc4_);
  88.                }
  89.                _loc3_++;
  90.             }
  91.             if(_loc2_)
  92.             {
  93.                listChangeHandler(_loc2_);
  94.             }
  95.          }
  96.       }
  97.       
  98.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  99.       {
  100.          eventDispatcher.removeEventListener(param1,param2,param3);
  101.       }
  102.       
  103.       private function replaceItemsInView(param1:Array, param2:int, param3:Boolean = true) : void
  104.       {
  105.          var _loc4_:int = 0;
  106.          var _loc5_:Array = null;
  107.          var _loc6_:Array = null;
  108.          var _loc7_:int = 0;
  109.          var _loc8_:PropertyChangeEvent = null;
  110.          var _loc9_:CollectionEvent = null;
  111.          if(localIndex)
  112.          {
  113.             _loc4_ = param1.length;
  114.             _loc5_ = [];
  115.             _loc6_ = [];
  116.             _loc7_ = 0;
  117.             while(_loc7_ < _loc4_)
  118.             {
  119.                _loc8_ = param1[_loc7_];
  120.                _loc5_.push(_loc8_.oldValue);
  121.                _loc6_.push(_loc8_.newValue);
  122.                _loc7_++;
  123.             }
  124.             removeItemsFromView(_loc5_,param2,param3);
  125.             addItemsToView(_loc6_,param2,param3);
  126.          }
  127.          else
  128.          {
  129.             (_loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.REPLACE;
  130.             _loc9_.location = param2;
  131.             _loc9_.items = param1;
  132.             dispatchEvent(_loc9_);
  133.          }
  134.       }
  135.       
  136.       public function willTrigger(param1:String) : Boolean
  137.       {
  138.          return eventDispatcher.willTrigger(param1);
  139.       }
  140.       
  141.       private function getFilteredItemIndex(param1:Object) : int
  142.       {
  143.          var _loc4_:Object = null;
  144.          var _loc5_:int = 0;
  145.          var _loc6_:int = 0;
  146.          var _loc2_:int = list.getItemIndex(param1);
  147.          if(_loc2_ == 0)
  148.          {
  149.             return 0;
  150.          }
  151.          var _loc3_:int = _loc2_ - 1;
  152.          while(_loc3_ >= 0)
  153.          {
  154.             _loc4_ = list.getItemAt(_loc3_);
  155.             if(filterFunction(_loc4_))
  156.             {
  157.                _loc5_ = localIndex.length;
  158.                _loc6_ = 0;
  159.                while(_loc6_ < _loc5_)
  160.                {
  161.                   if(localIndex[_loc6_] == _loc4_)
  162.                   {
  163.                      return _loc6_ + 1;
  164.                   }
  165.                   _loc6_++;
  166.                }
  167.             }
  168.             _loc3_--;
  169.          }
  170.          return 0;
  171.       }
  172.       
  173.       mx_internal function findItem(param1:Object, param2:String, param3:Boolean = false) : int
  174.       {
  175.          var _loc4_:String = null;
  176.          if(!sort)
  177.          {
  178.             _loc4_ = resourceManager.getString("collections","itemNotFound");
  179.             throw new CollectionViewError(_loc4_);
  180.          }
  181.          if(localIndex.length == 0)
  182.          {
  183.             return !!param3 ? 0 : -1;
  184.          }
  185.          return sort.findItem(localIndex,param1,param2,param3);
  186.       }
  187.       
  188.       override flash_proxy function nextName(param1:int) : String
  189.       {
  190.          return (param1 - 1).toString();
  191.       }
  192.       
  193.       public function removeAll() : void
  194.       {
  195.          var _loc2_:int = 0;
  196.          var _loc1_:int = length;
  197.          if(_loc1_ > 0)
  198.          {
  199.             if(localIndex)
  200.             {
  201.                _loc2_ = _loc1_ - 1;
  202.                while(_loc2_ >= 0)
  203.                {
  204.                   removeItemAt(_loc2_);
  205.                   _loc2_--;
  206.                }
  207.             }
  208.             else
  209.             {
  210.                list.removeAll();
  211.             }
  212.          }
  213.       }
  214.       
  215.       override flash_proxy function hasProperty(param1:*) : Boolean
  216.       {
  217.          var n:Number = NaN;
  218.          var name:* = param1;
  219.          if(name is QName)
  220.          {
  221.             name = name.localName;
  222.          }
  223.          var index:int = -1;
  224.          try
  225.          {
  226.             n = parseInt(String(name));
  227.             if(!isNaN(n))
  228.             {
  229.                index = int(n);
  230.             }
  231.          }
  232.          catch(e:Error)
  233.          {
  234.          }
  235.          if(index == -1)
  236.          {
  237.             return false;
  238.          }
  239.          return index >= 0 && index < length;
  240.       }
  241.       
  242.       [Bindable("collectionChange")]
  243.       public function getItemAt(param1:int, param2:int = 0) : Object
  244.       {
  245.          var _loc3_:String = null;
  246.          if(param1 < 0 || param1 >= length)
  247.          {
  248.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  249.             throw new RangeError(_loc3_);
  250.          }
  251.          if(localIndex)
  252.          {
  253.             return localIndex[param1];
  254.          }
  255.          if(list)
  256.          {
  257.             return list.getItemAt(param1,param2);
  258.          }
  259.          return null;
  260.       }
  261.       
  262.       private function moveItemInView(param1:Object, param2:Boolean = true, param3:Array = null) : void
  263.       {
  264.          var _loc4_:int = 0;
  265.          var _loc5_:int = 0;
  266.          var _loc6_:int = 0;
  267.          var _loc7_:CollectionEvent = null;
  268.          if(localIndex)
  269.          {
  270.             _loc4_ = -1;
  271.             _loc5_ = 0;
  272.             while(_loc5_ < localIndex.length)
  273.             {
  274.                if(localIndex[_loc5_] == param1)
  275.                {
  276.                   _loc4_ = _loc5_;
  277.                   break;
  278.                }
  279.                _loc5_++;
  280.             }
  281.             if(_loc4_ > -1)
  282.             {
  283.                localIndex.splice(_loc4_,1);
  284.             }
  285.             _loc6_ = addItemsToView([param1],_loc4_,false);
  286.             if(param2)
  287.             {
  288.                (_loc7_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).items.push(param1);
  289.                if(param3 && _loc6_ == _loc4_ && _loc6_ > -1)
  290.                {
  291.                   param3.push(param1);
  292.                   return;
  293.                }
  294.                if(_loc6_ > -1 && _loc4_ > -1)
  295.                {
  296.                   _loc7_.kind = CollectionEventKind.MOVE;
  297.                   _loc7_.location = _loc6_;
  298.                   _loc7_.oldLocation = _loc4_;
  299.                }
  300.                else if(_loc6_ > -1)
  301.                {
  302.                   _loc7_.kind = CollectionEventKind.ADD;
  303.                   _loc7_.location = _loc6_;
  304.                }
  305.                else if(_loc4_ > -1)
  306.                {
  307.                   _loc7_.kind = CollectionEventKind.REMOVE;
  308.                   _loc7_.location = _loc4_;
  309.                }
  310.                else
  311.                {
  312.                   param2 = false;
  313.                }
  314.                if(param2)
  315.                {
  316.                   dispatchEvent(_loc7_);
  317.                }
  318.             }
  319.          }
  320.       }
  321.       
  322.       public function contains(param1:Object) : Boolean
  323.       {
  324.          return getItemIndex(param1) != -1;
  325.       }
  326.       
  327.       [Bindable("sortChanged")]
  328.       public function get sort() : Sort
  329.       {
  330.          return _sort;
  331.       }
  332.       
  333.       private function removeItemsFromView(param1:Array, param2:int, param3:Boolean = true) : void
  334.       {
  335.          var _loc6_:int = 0;
  336.          var _loc7_:Object = null;
  337.          var _loc8_:int = 0;
  338.          var _loc9_:CollectionEvent = null;
  339.          var _loc4_:Array = !!localIndex ? [] : param1;
  340.          var _loc5_:int = param2;
  341.          if(localIndex)
  342.          {
  343.             _loc6_ = 0;
  344.             while(_loc6_ < param1.length)
  345.             {
  346.                _loc7_ = param1[_loc6_];
  347.                if((_loc8_ = getItemIndex(_loc7_)) > -1)
  348.                {
  349.                   localIndex.splice(_loc8_,1);
  350.                   _loc4_.push(_loc7_);
  351.                   _loc5_ = _loc8_;
  352.                }
  353.                _loc6_++;
  354.             }
  355.          }
  356.          if(param3 && _loc4_.length > 0)
  357.          {
  358.             (_loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.REMOVE;
  359.             _loc9_.location = !localIndex || _loc4_.length == 1 ? int(_loc5_) : -1;
  360.             _loc9_.items = _loc4_;
  361.             dispatchEvent(_loc9_);
  362.          }
  363.       }
  364.       
  365.       [Bindable("listChanged")]
  366.       public function get list() : IList
  367.       {
  368.          return _list;
  369.       }
  370.       
  371.       public function addItemAt(param1:Object, param2:int) : void
  372.       {
  373.          var _loc4_:String = null;
  374.          if(param2 < 0 || !list || param2 > length)
  375.          {
  376.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  377.             throw new RangeError(_loc4_);
  378.          }
  379.          var _loc3_:int = param2;
  380.          if(localIndex && sort)
  381.          {
  382.             _loc3_ = list.length;
  383.          }
  384.          else if(localIndex && filterFunction != null)
  385.          {
  386.             if(_loc3_ == localIndex.length)
  387.             {
  388.                _loc3_ = list.length;
  389.             }
  390.             else
  391.             {
  392.                _loc3_ = list.getItemIndex(localIndex[param2]);
  393.             }
  394.          }
  395.          list.addItemAt(param1,_loc3_);
  396.       }
  397.       
  398.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  399.       {
  400.          list.itemUpdated(param1,param2,param3,param4);
  401.       }
  402.       
  403.       private function populateLocalIndex() : void
  404.       {
  405.          if(list)
  406.          {
  407.             localIndex = list.toArray();
  408.          }
  409.          else
  410.          {
  411.             localIndex = [];
  412.          }
  413.       }
  414.       
  415.       private function handlePropertyChangeEvents(param1:Array) : void
  416.       {
  417.          var _loc3_:Array = null;
  418.          var _loc4_:Object = null;
  419.          var _loc5_:int = 0;
  420.          var _loc6_:Array = null;
  421.          var _loc7_:int = 0;
  422.          var _loc8_:PropertyChangeEvent = null;
  423.          var _loc9_:Object = null;
  424.          var _loc10_:* = false;
  425.          var _loc11_:int = 0;
  426.          var _loc12_:int = 0;
  427.          var _loc13_:CollectionEvent = null;
  428.          var _loc2_:Array = param1;
  429.          if(sort || filterFunction != null)
  430.          {
  431.             _loc3_ = [];
  432.             _loc5_ = 0;
  433.             while(_loc5_ < param1.length)
  434.             {
  435.                if((_loc8_ = param1[_loc5_]).target)
  436.                {
  437.                   _loc9_ = _loc8_.target;
  438.                   _loc10_ = _loc8_.target != _loc8_.source;
  439.                }
  440.                else
  441.                {
  442.                   _loc9_ = _loc8_.source;
  443.                   _loc10_ = false;
  444.                }
  445.                _loc11_ = 0;
  446.                while(_loc11_ < _loc3_.length)
  447.                {
  448.                   if(_loc3_[_loc11_].item == _loc9_)
  449.                   {
  450.                      break;
  451.                   }
  452.                   _loc11_++;
  453.                }
  454.                if(_loc11_ < _loc3_.length)
  455.                {
  456.                   _loc4_ = _loc3_[_loc11_];
  457.                }
  458.                else
  459.                {
  460.                   _loc4_ = {
  461.                      "item":_loc9_,
  462.                      "move":_loc10_,
  463.                      "event":_loc8_
  464.                   };
  465.                   _loc3_.push(_loc4_);
  466.                }
  467.                _loc4_.move = _loc4_.move || filterFunction || !_loc8_.property || sort && sort.propertyAffectsSort(String(_loc8_.property));
  468.                _loc5_++;
  469.             }
  470.             _loc2_ = [];
  471.             _loc5_ = 0;
  472.             while(_loc5_ < _loc3_.length)
  473.             {
  474.                if((_loc4_ = _loc3_[_loc5_]).move)
  475.                {
  476.                   moveItemInView(_loc4_.item,_loc4_.item,_loc2_);
  477.                }
  478.                else
  479.                {
  480.                   _loc2_.push(_loc4_.item);
  481.                }
  482.                _loc5_++;
  483.             }
  484.             _loc6_ = [];
  485.             _loc7_ = 0;
  486.             while(_loc7_ < _loc2_.length)
  487.             {
  488.                _loc12_ = 0;
  489.                while(_loc12_ < _loc3_.length)
  490.                {
  491.                   if(_loc2_[_loc7_] == _loc3_[_loc12_].item)
  492.                   {
  493.                      _loc6_.push(_loc3_[_loc12_].event);
  494.                   }
  495.                   _loc12_++;
  496.                }
  497.                _loc7_++;
  498.             }
  499.             _loc2_ = _loc6_;
  500.          }
  501.          if(_loc2_.length > 0)
  502.          {
  503.             (_loc13_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.UPDATE;
  504.             _loc13_.items = _loc2_;
  505.             dispatchEvent(_loc13_);
  506.          }
  507.       }
  508.       
  509.       public function set sort(param1:Sort) : void
  510.       {
  511.          _sort = param1;
  512.          dispatchEvent(new Event("sortChanged"));
  513.       }
  514.       
  515.       override flash_proxy function nextValue(param1:int) : *
  516.       {
  517.          return getItemAt(param1 - 1);
  518.       }
  519.       
  520.       public function setItemAt(param1:Object, param2:int) : Object
  521.       {
  522.          var _loc4_:String = null;
  523.          var _loc5_:Object = null;
  524.          if(param2 < 0 || !list || param2 >= length)
  525.          {
  526.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  527.             throw new RangeError(_loc4_);
  528.          }
  529.          var _loc3_:int = param2;
  530.          if(localIndex)
  531.          {
  532.             if(param2 > localIndex.length)
  533.             {
  534.                _loc3_ = list.length;
  535.             }
  536.             else
  537.             {
  538.                _loc5_ = localIndex[param2];
  539.                _loc3_ = list.getItemIndex(_loc5_);
  540.             }
  541.          }
  542.          return list.setItemAt(param1,_loc3_);
  543.       }
  544.       
  545.       mx_internal function getBookmark(param1:int) : ListCollectionViewBookmark
  546.       {
  547.          var value:Object = null;
  548.          var message:String = null;
  549.          var index:int = param1;
  550.          if(index < 0 || index > length)
  551.          {
  552.             message = resourceManager.getString("collections","invalidIndex",[index]);
  553.             throw new CollectionViewError(message);
  554.          }
  555.          try
  556.          {
  557.             value = getItemAt(index);
  558.          }
  559.          catch(e:Error)
  560.          {
  561.             value = null;
  562.          }
  563.          return new ListCollectionViewBookmark(value,this,revision,index);
  564.       }
  565.       
  566.       private function addItemsToView(param1:Array, param2:int, param3:Boolean = true) : int
  567.       {
  568.          var _loc7_:int = 0;
  569.          var _loc8_:int = 0;
  570.          var _loc9_:Object = null;
  571.          var _loc10_:String = null;
  572.          var _loc11_:CollectionEvent = null;
  573.          var _loc4_:Array = !!localIndex ? [] : param1;
  574.          var _loc5_:int = param2;
  575.          var _loc6_:Boolean = true;
  576.          if(localIndex)
  577.          {
  578.             _loc7_ = param2;
  579.             _loc8_ = 0;
  580.             while(_loc8_ < param1.length)
  581.             {
  582.                _loc9_ = param1[_loc8_];
  583.                if(filterFunction == null || filterFunction(_loc9_))
  584.                {
  585.                   if(sort)
  586.                   {
  587.                      _loc7_ = findItem(_loc9_,Sort.ANY_INDEX_MODE,true);
  588.                      if(_loc6_)
  589.                      {
  590.                         _loc5_ = _loc7_;
  591.                         _loc6_ = false;
  592.                      }
  593.                   }
  594.                   else
  595.                   {
  596.                      _loc7_ = getFilteredItemIndex(_loc9_);
  597.                      if(_loc6_)
  598.                      {
  599.                         _loc5_ = _loc7_;
  600.                         _loc6_ = false;
  601.                      }
  602.                   }
  603.                   if(sort && sort.unique && sort.compareFunction(_loc9_,localIndex[_loc7_]) == 0)
  604.                   {
  605.                      _loc10_ = resourceManager.getString("collections","incorrectAddition");
  606.                      throw new CollectionViewError(_loc10_);
  607.                   }
  608.                   localIndex.splice(_loc7_++,0,_loc9_);
  609.                   _loc4_.push(_loc9_);
  610.                }
  611.                else
  612.                {
  613.                   _loc5_ = -1;
  614.                }
  615.                _loc8_++;
  616.             }
  617.          }
  618.          if(localIndex && _loc4_.length > 1)
  619.          {
  620.             _loc5_ = -1;
  621.          }
  622.          if(param3 && _loc4_.length > 0)
  623.          {
  624.             (_loc11_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.ADD;
  625.             _loc11_.location = _loc5_;
  626.             _loc11_.items = _loc4_;
  627.             dispatchEvent(_loc11_);
  628.          }
  629.          return _loc5_;
  630.       }
  631.       
  632.       public function dispatchEvent(param1:Event) : Boolean
  633.       {
  634.          return eventDispatcher.dispatchEvent(param1);
  635.       }
  636.       
  637.       public function set list(param1:IList) : void
  638.       {
  639.          var _loc2_:* = false;
  640.          var _loc3_:* = false;
  641.          if(_list != param1)
  642.          {
  643.             if(_list)
  644.             {
  645.                _list.removeEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler);
  646.                _loc2_ = _list.length > 0;
  647.             }
  648.             _list = param1;
  649.             if(_list)
  650.             {
  651.                _list.addEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler,false,0,true);
  652.                _loc3_ = _list.length > 0;
  653.             }
  654.             if(_loc2_ || _loc3_)
  655.             {
  656.                reset();
  657.             }
  658.             dispatchEvent(new Event("listChanged"));
  659.          }
  660.       }
  661.       
  662.       mx_internal function getBookmarkIndex(param1:CursorBookmark) : int
  663.       {
  664.          var _loc3_:String = null;
  665.          if(!(param1 is ListCollectionViewBookmark) || ListCollectionViewBookmark(param1).view != this)
  666.          {
  667.             _loc3_ = resourceManager.getString("collections","bookmarkNotFound");
  668.             throw new CollectionViewError(_loc3_);
  669.          }
  670.          var _loc2_:ListCollectionViewBookmark = ListCollectionViewBookmark(param1);
  671.          if(_loc2_.viewRevision != revision)
  672.          {
  673.             if(_loc2_.index < 0 || _loc2_.index >= length || getItemAt(_loc2_.index) != _loc2_.value)
  674.             {
  675.                _loc2_.index = getItemIndex(_loc2_.value);
  676.             }
  677.             _loc2_.viewRevision = revision;
  678.          }
  679.          return _loc2_.index;
  680.       }
  681.       
  682.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  683.       {
  684.          eventDispatcher.addEventListener(param1,param2,param3,param4,param5);
  685.       }
  686.       
  687.       public function getItemIndex(param1:Object) : int
  688.       {
  689.          var _loc2_:int = 0;
  690.          var _loc3_:int = 0;
  691.          var _loc4_:int = 0;
  692.          var _loc5_:int = 0;
  693.          if(sort)
  694.          {
  695.             _loc3_ = sort.findItem(localIndex,param1,Sort.FIRST_INDEX_MODE);
  696.             if(_loc3_ == -1)
  697.             {
  698.                return -1;
  699.             }
  700.             _loc4_ = sort.findItem(localIndex,param1,Sort.LAST_INDEX_MODE);
  701.             _loc2_ = _loc3_;
  702.             while(_loc2_ <= _loc4_)
  703.             {
  704.                if(localIndex[_loc2_] == param1)
  705.                {
  706.                   return _loc2_;
  707.                }
  708.                _loc2_++;
  709.             }
  710.             return -1;
  711.          }
  712.          if(filterFunction != null)
  713.          {
  714.             _loc5_ = localIndex.length;
  715.             _loc2_ = 0;
  716.             while(_loc2_ < _loc5_)
  717.             {
  718.                if(localIndex[_loc2_] == param1)
  719.                {
  720.                   return _loc2_;
  721.                }
  722.                _loc2_++;
  723.             }
  724.             return -1;
  725.          }
  726.          return list.getItemIndex(param1);
  727.       }
  728.       
  729.       public function removeItemAt(param1:int) : Object
  730.       {
  731.          var _loc3_:String = null;
  732.          var _loc4_:Object = null;
  733.          if(param1 < 0 || param1 >= length)
  734.          {
  735.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  736.             throw new RangeError(_loc3_);
  737.          }
  738.          var _loc2_:int = param1;
  739.          if(localIndex)
  740.          {
  741.             _loc4_ = localIndex[param1];
  742.             _loc2_ = list.getItemIndex(_loc4_);
  743.          }
  744.          return list.removeItemAt(_loc2_);
  745.       }
  746.       
  747.       override flash_proxy function getProperty(param1:*) : *
  748.       {
  749.          var n:Number = NaN;
  750.          var message:String = null;
  751.          var name:* = param1;
  752.          if(name is QName)
  753.          {
  754.             name = name.localName;
  755.          }
  756.          var index:int = -1;
  757.          try
  758.          {
  759.             n = parseInt(String(name));
  760.             if(!isNaN(n))
  761.             {
  762.                index = int(n);
  763.             }
  764.          }
  765.          catch(e:Error)
  766.          {
  767.          }
  768.          if(index == -1)
  769.          {
  770.             message = resourceManager.getString("collections","unknownProperty",[name]);
  771.             throw new Error(message);
  772.          }
  773.          return getItemAt(index);
  774.       }
  775.       
  776.       public function enableAutoUpdate() : void
  777.       {
  778.          if(autoUpdateCounter > 0)
  779.          {
  780.             --autoUpdateCounter;
  781.             if(autoUpdateCounter == 0)
  782.             {
  783.                handlePendingUpdates();
  784.             }
  785.          }
  786.       }
  787.       
  788.       mx_internal function reset() : void
  789.       {
  790.          var _loc1_:CollectionEvent = null;
  791.          internalRefresh(false);
  792.          if(mx_internal::dispatchResetEvent)
  793.          {
  794.             _loc1_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  795.             _loc1_.kind = CollectionEventKind.RESET;
  796.             dispatchEvent(_loc1_);
  797.          }
  798.       }
  799.       
  800.       public function toArray() : Array
  801.       {
  802.          var _loc1_:Array = null;
  803.          if(localIndex)
  804.          {
  805.             _loc1_ = localIndex.concat();
  806.          }
  807.          else
  808.          {
  809.             _loc1_ = list.toArray();
  810.          }
  811.          return _loc1_;
  812.       }
  813.       
  814.       override flash_proxy function callProperty(param1:*, ... rest) : *
  815.       {
  816.          return null;
  817.       }
  818.       
  819.       public function initialized(param1:Object, param2:String) : void
  820.       {
  821.          refresh();
  822.       }
  823.       
  824.       override flash_proxy function setProperty(param1:*, param2:*) : void
  825.       {
  826.          var n:Number = NaN;
  827.          var message:String = null;
  828.          var name:* = param1;
  829.          var value:* = param2;
  830.          if(name is QName)
  831.          {
  832.             name = name.localName;
  833.          }
  834.          var index:int = -1;
  835.          try
  836.          {
  837.             n = parseInt(String(name));
  838.             if(!isNaN(n))
  839.             {
  840.                index = int(n);
  841.             }
  842.          }
  843.          catch(e:Error)
  844.          {
  845.          }
  846.          if(index == -1)
  847.          {
  848.             message = resourceManager.getString("collections","unknownProperty",[name]);
  849.             throw new Error(message);
  850.          }
  851.          setItemAt(value,index);
  852.       }
  853.       
  854.       public function addItem(param1:Object) : void
  855.       {
  856.          addItemAt(param1,length);
  857.       }
  858.       
  859.       private function internalRefresh(param1:Boolean) : Boolean
  860.       {
  861.          var tmp:Array = null;
  862.          var len:int = 0;
  863.          var i:int = 0;
  864.          var item:Object = null;
  865.          var refreshEvent:CollectionEvent = null;
  866.          var dispatch:Boolean = param1;
  867.          if(sort || filterFunction != null)
  868.          {
  869.             try
  870.             {
  871.                populateLocalIndex();
  872.             }
  873.             catch(pending:ItemPendingError)
  874.             {
  875.                pending.addResponder(new ItemResponder(function(param1:Object, param2:Object = null):void
  876.                {
  877.                   internalRefresh(dispatch);
  878.                },function(param1:Object, param2:Object = null):void
  879.                {
  880.                }));
  881.                return false;
  882.             }
  883.             if(filterFunction != null)
  884.             {
  885.                tmp = [];
  886.                len = localIndex.length;
  887.                i = 0;
  888.                while(i < len)
  889.                {
  890.                   item = localIndex[i];
  891.                   if(filterFunction(item))
  892.                   {
  893.                      tmp.push(item);
  894.                   }
  895.                   i++;
  896.                }
  897.                localIndex = tmp;
  898.             }
  899.             if(sort)
  900.             {
  901.                sort.sort(localIndex);
  902.                dispatch = true;
  903.             }
  904.          }
  905.          else if(localIndex)
  906.          {
  907.             localIndex = null;
  908.          }
  909.          ++revision;
  910.          pendingUpdates = null;
  911.          if(dispatch)
  912.          {
  913.             refreshEvent = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  914.             refreshEvent.kind = CollectionEventKind.REFRESH;
  915.             dispatchEvent(refreshEvent);
  916.          }
  917.          return true;
  918.       }
  919.       
  920.       public function set filterFunction(param1:Function) : void
  921.       {
  922.          _filterFunction = param1;
  923.          dispatchEvent(new Event("filterFunctionChanged"));
  924.       }
  925.       
  926.       public function refresh() : Boolean
  927.       {
  928.          return internalRefresh(true);
  929.       }
  930.       
  931.       [Bindable("filterFunctionChanged")]
  932.       public function get filterFunction() : Function
  933.       {
  934.          return _filterFunction;
  935.       }
  936.       
  937.       public function createCursor() : IViewCursor
  938.       {
  939.          return new ListCollectionViewCursor(this);
  940.       }
  941.       
  942.       public function hasEventListener(param1:String) : Boolean
  943.       {
  944.          return eventDispatcher.hasEventListener(param1);
  945.       }
  946.       
  947.       [Bindable("collectionChange")]
  948.       public function get length() : int
  949.       {
  950.          if(localIndex)
  951.          {
  952.             return localIndex.length;
  953.          }
  954.          if(list)
  955.          {
  956.             return list.length;
  957.          }
  958.          return 0;
  959.       }
  960.       
  961.       override flash_proxy function nextNameIndex(param1:int) : int
  962.       {
  963.          return param1 < length ? int(param1 + 1) : 0;
  964.       }
  965.       
  966.       public function disableAutoUpdate() : void
  967.       {
  968.          ++autoUpdateCounter;
  969.       }
  970.       
  971.       public function toString() : String
  972.       {
  973.          if(localIndex)
  974.          {
  975.             return ObjectUtil.toString(localIndex);
  976.          }
  977.          if(list && Object(list).toString)
  978.          {
  979.             return Object(list).toString();
  980.          }
  981.          return getQualifiedClassName(this);
  982.       }
  983.       
  984.       private function listChangeHandler(param1:CollectionEvent) : void
  985.       {
  986.          if(autoUpdateCounter > 0)
  987.          {
  988.             if(!pendingUpdates)
  989.             {
  990.                pendingUpdates = [];
  991.             }
  992.             pendingUpdates.push(param1);
  993.          }
  994.          else
  995.          {
  996.             switch(param1.kind)
  997.             {
  998.                case CollectionEventKind.ADD:
  999.                   addItemsToView(param1.items,param1.location);
  1000.                   break;
  1001.                case CollectionEventKind.RESET:
  1002.                   reset();
  1003.                   break;
  1004.                case CollectionEventKind.REMOVE:
  1005.                   removeItemsFromView(param1.items,param1.location);
  1006.                   break;
  1007.                case CollectionEventKind.REPLACE:
  1008.                   replaceItemsInView(param1.items,param1.location);
  1009.                   break;
  1010.                case CollectionEventKind.UPDATE:
  1011.                   handlePropertyChangeEvents(param1.items);
  1012.                   break;
  1013.                default:
  1014.                   dispatchEvent(param1);
  1015.             }
  1016.          }
  1017.       }
  1018.    }
  1019. }
  1020.  
  1021. import mx.collections.CursorBookmark;
  1022. import mx.collections.ListCollectionView;
  1023. import mx.core.mx_internal;
  1024.  
  1025. use namespace mx_internal;
  1026.  
  1027. class ListCollectionViewBookmark extends CursorBookmark
  1028. {
  1029.     
  1030.    
  1031.    mx_internal var viewRevision:int;
  1032.    
  1033.    mx_internal var index:int;
  1034.    
  1035.    mx_internal var view:ListCollectionView;
  1036.    
  1037.    function ListCollectionViewBookmark(param1:Object, param2:ListCollectionView, param3:int, param4:int)
  1038.    {
  1039.       super(param1);
  1040.       this.view = param2;
  1041.       this.viewRevision = param3;
  1042.       this.index = param4;
  1043.    }
  1044.    
  1045.    override public function getViewIndex() : int
  1046.    {
  1047.       return mx_internal::view.getBookmarkIndex(this);
  1048.    }
  1049. }
  1050.  
  1051. import flash.events.EventDispatcher;
  1052. import mx.collections.CursorBookmark;
  1053. import mx.collections.ICollectionView;
  1054. import mx.collections.IViewCursor;
  1055. import mx.collections.ListCollectionView;
  1056. import mx.collections.Sort;
  1057. import mx.collections.errors.CollectionViewError;
  1058. import mx.collections.errors.CursorError;
  1059. import mx.collections.errors.ItemPendingError;
  1060. import mx.collections.errors.SortError;
  1061. import mx.core.mx_internal;
  1062. import mx.events.CollectionEvent;
  1063. import mx.events.CollectionEventKind;
  1064. import mx.events.FlexEvent;
  1065. import mx.resources.IResourceManager;
  1066. import mx.resources.ResourceManager;
  1067.  
  1068. use namespace mx_internal;
  1069.  
  1070. class ListCollectionViewCursor extends EventDispatcher implements IViewCursor
  1071. {
  1072.    
  1073.    private static const BEFORE_FIRST_INDEX:int = -1;
  1074.    
  1075.    private static const AFTER_LAST_INDEX:int = -2;
  1076.     
  1077.    
  1078.    private var _view:ListCollectionView;
  1079.    
  1080.    private var invalid:Boolean;
  1081.    
  1082.    private var resourceManager:IResourceManager;
  1083.    
  1084.    private var currentIndex:int;
  1085.    
  1086.    private var currentValue:Object;
  1087.    
  1088.    function ListCollectionViewCursor(param1:ListCollectionView)
  1089.    {
  1090.       var view:ListCollectionView = param1;
  1091.       resourceManager = ResourceManager.getInstance();
  1092.       super();
  1093.       _view = view;
  1094.       _view.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionEventHandler,false,0,true);
  1095.       currentIndex = view.length > 0 ? 0 : int(AFTER_LAST_INDEX);
  1096.       if(currentIndex == 0)
  1097.       {
  1098.          try
  1099.          {
  1100.             setCurrent(view.getItemAt(0),false);
  1101.          }
  1102.          catch(e:ItemPendingError)
  1103.          {
  1104.             currentIndex = BEFORE_FIRST_INDEX;
  1105.             setCurrent(null,false);
  1106.          }
  1107.       }
  1108.    }
  1109.    
  1110.    public function findAny(param1:Object) : Boolean
  1111.    {
  1112.       var index:int = 0;
  1113.       var values:Object = param1;
  1114.       checkValid();
  1115.       var lcView:ListCollectionView = ListCollectionView(view);
  1116.       try
  1117.       {
  1118.          index = lcView.findItem(values,Sort.ANY_INDEX_MODE);
  1119.       }
  1120.       catch(e:SortError)
  1121.       {
  1122.          throw new CursorError(e.message);
  1123.       }
  1124.       if(index > -1)
  1125.       {
  1126.          currentIndex = index;
  1127.          setCurrent(lcView.getItemAt(currentIndex));
  1128.       }
  1129.       return index > -1;
  1130.    }
  1131.    
  1132.    public function remove() : Object
  1133.    {
  1134.       var oldIndex:int = 0;
  1135.       var message:String = null;
  1136.       if(beforeFirst || afterLast)
  1137.       {
  1138.          message = resourceManager.getString("collections","invalidRemove");
  1139.          throw new CursorError(message);
  1140.       }
  1141.       oldIndex = currentIndex;
  1142.       ++currentIndex;
  1143.       if(currentIndex >= view.length)
  1144.       {
  1145.          currentIndex = AFTER_LAST_INDEX;
  1146.          setCurrent(null);
  1147.       }
  1148.       else
  1149.       {
  1150.          try
  1151.          {
  1152.             setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1153.          }
  1154.          catch(e:ItemPendingError)
  1155.          {
  1156.             setCurrent(null,false);
  1157.             ListCollectionView(view).removeItemAt(oldIndex);
  1158.             throw e;
  1159.          }
  1160.       }
  1161.       var removed:Object = ListCollectionView(view).removeItemAt(oldIndex);
  1162.       return removed;
  1163.    }
  1164.    
  1165.    private function setCurrent(param1:Object, param2:Boolean = true) : void
  1166.    {
  1167.       currentValue = param1;
  1168.       if(param2)
  1169.       {
  1170.          dispatchEvent(new FlexEvent(FlexEvent.CURSOR_UPDATE));
  1171.       }
  1172.    }
  1173.    
  1174.    public function seek(param1:CursorBookmark, param2:int = 0, param3:int = 0) : void
  1175.    {
  1176.       var message:String = null;
  1177.       var bookmark:CursorBookmark = param1;
  1178.       var offset:int = param2;
  1179.       var prefetch:int = param3;
  1180.       checkValid();
  1181.       if(view.length == 0)
  1182.       {
  1183.          currentIndex = AFTER_LAST_INDEX;
  1184.          setCurrent(null,false);
  1185.          return;
  1186.       }
  1187.       var newIndex:int = currentIndex;
  1188.       if(bookmark == CursorBookmark.FIRST)
  1189.       {
  1190.          newIndex = 0;
  1191.       }
  1192.       else if(bookmark == CursorBookmark.LAST)
  1193.       {
  1194.          newIndex = view.length - 1;
  1195.       }
  1196.       else if(bookmark != CursorBookmark.CURRENT)
  1197.       {
  1198.          try
  1199.          {
  1200.             newIndex = ListCollectionView(view).getBookmarkIndex(bookmark);
  1201.             if(newIndex < 0)
  1202.             {
  1203.                setCurrent(null);
  1204.                message = resourceManager.getString("collections","bookmarkInvalid");
  1205.                throw new CursorError(message);
  1206.             }
  1207.          }
  1208.          catch(bmError:CollectionViewError)
  1209.          {
  1210.             message = resourceManager.getString("collections","bookmarkInvalid");
  1211.             throw new CursorError(message);
  1212.          }
  1213.       }
  1214.       newIndex += offset;
  1215.       var newCurrent:Object = null;
  1216.       if(newIndex >= view.length)
  1217.       {
  1218.          currentIndex = AFTER_LAST_INDEX;
  1219.       }
  1220.       else if(newIndex < 0)
  1221.       {
  1222.          currentIndex = BEFORE_FIRST_INDEX;
  1223.       }
  1224.       else
  1225.       {
  1226.          newCurrent = ListCollectionView(view).getItemAt(newIndex,prefetch);
  1227.          currentIndex = newIndex;
  1228.       }
  1229.       setCurrent(newCurrent);
  1230.    }
  1231.    
  1232.    public function insert(param1:Object) : void
  1233.    {
  1234.       var _loc2_:int = 0;
  1235.       var _loc3_:String = null;
  1236.       if(afterLast)
  1237.       {
  1238.          _loc2_ = view.length;
  1239.       }
  1240.       else if(beforeFirst)
  1241.       {
  1242.          if(view.length > 0)
  1243.          {
  1244.             _loc3_ = resourceManager.getString("collections","invalidInsert");
  1245.             throw new CursorError(_loc3_);
  1246.          }
  1247.          _loc2_ = 0;
  1248.       }
  1249.       else
  1250.       {
  1251.          _loc2_ = currentIndex;
  1252.       }
  1253.       ListCollectionView(view).addItemAt(param1,_loc2_);
  1254.    }
  1255.    
  1256.    [Bindable("cursorUpdate")]
  1257.    public function get afterLast() : Boolean
  1258.    {
  1259.       checkValid();
  1260.       return currentIndex == AFTER_LAST_INDEX || view.length == 0;
  1261.    }
  1262.    
  1263.    private function checkValid() : void
  1264.    {
  1265.       var _loc1_:String = null;
  1266.       if(invalid)
  1267.       {
  1268.          _loc1_ = resourceManager.getString("collections","invalidCursor");
  1269.          throw new CursorError(_loc1_);
  1270.       }
  1271.    }
  1272.    
  1273.    private function collectionEventHandler(param1:CollectionEvent) : void
  1274.    {
  1275.       var event:CollectionEvent = param1;
  1276.       switch(event.kind)
  1277.       {
  1278.          case CollectionEventKind.ADD:
  1279.             if(event.location <= currentIndex)
  1280.             {
  1281.                currentIndex += event.items.length;
  1282.             }
  1283.             break;
  1284.          case CollectionEventKind.REMOVE:
  1285.             if(event.location < currentIndex)
  1286.             {
  1287.                currentIndex -= event.items.length;
  1288.             }
  1289.             else if(event.location == currentIndex)
  1290.             {
  1291.                if(currentIndex < view.length)
  1292.                {
  1293.                   try
  1294.                   {
  1295.                      setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1296.                   }
  1297.                   catch(error:ItemPendingError)
  1298.                   {
  1299.                      setCurrent(null,false);
  1300.                   }
  1301.                }
  1302.                else
  1303.                {
  1304.                   currentIndex = AFTER_LAST_INDEX;
  1305.                   setCurrent(null);
  1306.                }
  1307.             }
  1308.             break;
  1309.          case CollectionEventKind.MOVE:
  1310.             if(event.oldLocation == currentIndex)
  1311.             {
  1312.                currentIndex = event.location;
  1313.             }
  1314.             else
  1315.             {
  1316.                if(event.oldLocation < currentIndex)
  1317.                {
  1318.                   currentIndex -= event.items.length;
  1319.                }
  1320.                if(event.location <= currentIndex)
  1321.                {
  1322.                   currentIndex += event.items.length;
  1323.                }
  1324.             }
  1325.             break;
  1326.          case CollectionEventKind.REFRESH:
  1327.             if(!(beforeFirst || afterLast))
  1328.             {
  1329.                currentIndex = ListCollectionView(view).getItemIndex(currentValue);
  1330.                if(currentIndex == -1)
  1331.                {
  1332.                   setCurrent(null);
  1333.                }
  1334.             }
  1335.             break;
  1336.          case CollectionEventKind.REPLACE:
  1337.             if(event.location == currentIndex)
  1338.             {
  1339.                try
  1340.                {
  1341.                   setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1342.                }
  1343.                catch(error:ItemPendingError)
  1344.                {
  1345.                   setCurrent(null,false);
  1346.                }
  1347.             }
  1348.             break;
  1349.          case CollectionEventKind.RESET:
  1350.             currentIndex = BEFORE_FIRST_INDEX;
  1351.             setCurrent(null);
  1352.       }
  1353.    }
  1354.    
  1355.    public function moveNext() : Boolean
  1356.    {
  1357.       if(afterLast)
  1358.       {
  1359.          return false;
  1360.       }
  1361.       var _loc1_:int = !!beforeFirst ? 0 : int(currentIndex + 1);
  1362.       if(_loc1_ >= view.length)
  1363.       {
  1364.          _loc1_ = AFTER_LAST_INDEX;
  1365.          setCurrent(null);
  1366.       }
  1367.       else
  1368.       {
  1369.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1370.       }
  1371.       currentIndex = _loc1_;
  1372.       return !afterLast;
  1373.    }
  1374.    
  1375.    public function get view() : ICollectionView
  1376.    {
  1377.       checkValid();
  1378.       return _view;
  1379.    }
  1380.    
  1381.    public function movePrevious() : Boolean
  1382.    {
  1383.       if(beforeFirst)
  1384.       {
  1385.          return false;
  1386.       }
  1387.       var _loc1_:int = !!afterLast ? int(view.length - 1) : int(currentIndex - 1);
  1388.       if(_loc1_ == -1)
  1389.       {
  1390.          _loc1_ = BEFORE_FIRST_INDEX;
  1391.          setCurrent(null);
  1392.       }
  1393.       else
  1394.       {
  1395.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1396.       }
  1397.       currentIndex = _loc1_;
  1398.       return !beforeFirst;
  1399.    }
  1400.    
  1401.    public function findLast(param1:Object) : Boolean
  1402.    {
  1403.       var index:int = 0;
  1404.       var values:Object = param1;
  1405.       checkValid();
  1406.       var lcView:ListCollectionView = ListCollectionView(view);
  1407.       try
  1408.       {
  1409.          index = lcView.findItem(values,Sort.LAST_INDEX_MODE);
  1410.       }
  1411.       catch(sortError:SortError)
  1412.       {
  1413.          throw new CursorError(sortError.message);
  1414.       }
  1415.       if(index > -1)
  1416.       {
  1417.          currentIndex = index;
  1418.          setCurrent(lcView.getItemAt(currentIndex));
  1419.       }
  1420.       return index > -1;
  1421.    }
  1422.    
  1423.    [Bindable("cursorUpdate")]
  1424.    public function get beforeFirst() : Boolean
  1425.    {
  1426.       checkValid();
  1427.       return currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
  1428.    }
  1429.    
  1430.    [Bindable("cursorUpdate")]
  1431.    public function get bookmark() : CursorBookmark
  1432.    {
  1433.       checkValid();
  1434.       if(view.length == 0 || beforeFirst)
  1435.       {
  1436.          return CursorBookmark.FIRST;
  1437.       }
  1438.       if(afterLast)
  1439.       {
  1440.          return CursorBookmark.LAST;
  1441.       }
  1442.       return ListCollectionView(view).getBookmark(currentIndex);
  1443.    }
  1444.    
  1445.    public function findFirst(param1:Object) : Boolean
  1446.    {
  1447.       var index:int = 0;
  1448.       var values:Object = param1;
  1449.       checkValid();
  1450.       var lcView:ListCollectionView = ListCollectionView(view);
  1451.       try
  1452.       {
  1453.          index = lcView.findItem(values,Sort.FIRST_INDEX_MODE);
  1454.       }
  1455.       catch(sortError:SortError)
  1456.       {
  1457.          throw new CursorError(sortError.message);
  1458.       }
  1459.       if(index > -1)
  1460.       {
  1461.          currentIndex = index;
  1462.          setCurrent(lcView.getItemAt(currentIndex));
  1463.       }
  1464.       return index > -1;
  1465.    }
  1466.    
  1467.    [Bindable("cursorUpdate")]
  1468.    public function get current() : Object
  1469.    {
  1470.       checkValid();
  1471.       return currentValue;
  1472.    }
  1473. }
  1474.